PrimFunc(params=[A_handle, B_handle, C_handle], ret_type=None, buffer_map={A_handle: A, B_handle: B, C_handle: C}, attrs={"global_symbol": "gemm"})
└── body=BlockRealize: with T.block("root"):
├── iter_values: []
├── predicate: T.bool8(True)
└── block: Block: with T.block("root", no_realize=True):
    ├── iter_vars: []
    ├── reads: []
    ├── writes: []
    ├── name_hint: 'root'
    ├── alloc_buffers: []
    ├── match_buffers: []
    ├── annotations: {}
    └── body: AttrStmt: with T.launch_thread("blockIdx.x", 8) as bx:
        ├── node: T.iter_var(bx, T.Range(0, 8), "ThreadIndex", "blockIdx.x")
        ├── attr_key: 'thread_extent'
        ├── value: 8
        └── body: AttrStmt: with T.launch_thread("blockIdx.y", 8) as by:
            ├── node: T.iter_var(by, T.Range(0, 8), "ThreadIndex", "blockIdx.y")
            ├── attr_key: 'thread_extent'
            ├── value: 8
            └── body: AttrStmt: with T.launch_thread("threadIdx.x", 128) as tx:
                ├── node: T.iter_var(tx, T.Range(0, 128), "ThreadIndex", "threadIdx.x")
                ├── attr_key: 'thread_extent'
                ├── value: 128
                └── body: AttrStmt: with T.launch_thread("threadIdx.y", 1) as ty:
                    ├── node: T.iter_var(ty, T.Range(0, 1), "ThreadIndex", "threadIdx.y")
                    ├── attr_key: 'thread_extent'
                    ├── value: 1
                    └── body: AttrStmt: with T.launch_thread("threadIdx.z", 1) as tz:
                        ├── node: T.iter_var(tz, T.Range(0, 1), "ThreadIndex", "threadIdx.z")
                        ├── attr_key: 'thread_extent'
                        ├── value: 1
                        └── body: BlockRealize: with T.block("tilelang_root"):
                            ├── iter_values: []
                            ├── predicate: T.bool8(True)
                            └── block: Block: with T.block("tilelang_root", no_realize=True):
                                ├── iter_vars: []
                                ├── reads: [A[by * 128, 0:993], B[0:993, bx * 128], C[by * 128, bx * 128]]
                                ├── writes: []
                                ├── name_hint: 'tilelang_root'
                                ├── alloc_buffers: [A_shared, B_shared, C_local]
                                ├── match_buffers: []
                                ├── annotations: {}
                                └── body: SeqStmt: C_local = T.Buffer((128, 128), scope="local.fragment")
                                    ├── seq0: Evaluate: C_local = T.Buffer((128, 128), scope="local.fragment")
                                    |   └── value: T.fill(T.region(C_local[0, 0], 2, 128, 128), 0)
                                    ├── seq1: For: for k in T.serial(32, annotations={"num_stages": 3}):
                                    |   ├── loop_var: k
                                    |   ├── min: 0
                                    |   ├── extent: 32
                                    |   ├── kind: 0
                                    |   ├── annotations: {'num_stages': 3}
                                    |   └── body: SeqStmt: A = T.Buffer((1024, 1024), "float16", strides=(1024, 1))
                                    |       ├── seq0: Evaluate: A = T.Buffer((1024, 1024), "float16", strides=(1024, 1))
                                    |       |   └── value: T.copy(T.region(A[by * 128, k * 32], 1, 128, 32), T.region(A_shared[0, 0], 2, 128, 32), -1, T.bool8(False), 0)
                                    |       ├── seq1: Evaluate: B = T.Buffer((1024, 1024), "float16", strides=(1024, 1))
                                    |       |   └── value: T.copy(T.region(B[k * 32, bx * 128], 1, 32, 128), T.region(B_shared[0, 0], 2, 32, 128), -1, T.bool8(False), 0)
                                    |       └── seq2: Evaluate: A_shared = T.Buffer((128, 32), "float16", scope="shared.dyn")
                                    |           └── value: T.gemm_py(T.region(A_shared[0, 0], 1, 128, 32), T.region(B_shared[0, 0], 1, 32, 128), T.region(C_local[0, 0], 3, 128, 128), T.boo...
                                    └── seq2: Evaluate: C_local = T.Buffer((128, 128), scope="local.fragment")
                                        └── value: T.copy(T.region(C_local[0, 0], 1, 128, 128), T.region(C[by * 128, bx * 128], 2, 128, 128), -1, T.bool8(False), 0)